// Copyright 2013 the V8 project authors. All rights reserved.
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
//       notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
//       copyright notice, this list of conditions and the following
//       disclaimer in the documentation and/or other materials provided
//       with the distribution.
//     * Neither the name of Google Inc. nor the names of its
//       contributors may be used to endorse or promote products derived
//       from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


// Performance.now is used in latency benchmarks, the fallback is Date.now.
var performance = performance || {};
performance.now = (function () {
  return performance.now ||
    performance.mozNow ||
    performance.msNow ||
    performance.oNow ||
    performance.webkitNow ||
    Date.now;
})();
let print = console.log;
// Simple framework for running the benchmark suites and
// computing a score based on the timing measurements.


// A benchmark has a name (string) and a function that will be run to
// do the performance measurement. The optional setup and tearDown
// arguments are functions that will be invoked before and after
// running the benchmark, but the running time of these functions will
// not be accounted for in the benchmark score.
function Benchmark(name, doWarmup, doDeterministic, deterministicIterations,
  run, setup, tearDown, rmsResult, minIterations) {
  this.name = name;
  this.doWarmup = doWarmup;
  this.doDeterministic = doDeterministic;
  this.deterministicIterations = deterministicIterations;
  this.run = run;
  this.Setup = setup ? setup : function () { };
  this.TearDown = tearDown ? tearDown : function () { };
  this.rmsResult = rmsResult ? rmsResult : null;
  this.minIterations = minIterations ? minIterations : 32;
}


// Benchmark results hold the benchmark and the measured time used to
// run the benchmark. The benchmark score is computed later once a
// full benchmark suite has run to completion. If latency is set to 0
// then there is no latency score for this benchmark.
function BenchmarkResult(benchmark, time, latency) {
  this.benchmark = benchmark;
  this.time = time;
  this.latency = latency;
}


// Automatically convert results to numbers. Used by the geometric
// mean computation.
BenchmarkResult.prototype.valueOf = function () {
  return this.time;
}


// Suites of benchmarks consist of a name and the set of benchmarks in
// addition to the reference timing that the final score will be based
// on. This way, all scores are relative to a reference run and higher
// scores implies better performance.
function BenchmarkSuite(name, reference, benchmarks) {
  this.name = name;
  this.reference = reference;
  this.benchmarks = benchmarks;
  BenchmarkSuite.suites.push(this);
}


// Keep track of all declared benchmark suites.
BenchmarkSuite.suites = [];

// Scores are not comparable across versions. Bump the version if
// you're making changes that will affect that scores, e.g. if you add
// a new benchmark or change an existing one.
BenchmarkSuite.version = '9';


// Defines global benchsuite running mode that overrides benchmark suite
// behavior. Intended to be set by the benchmark driver. Undefined
// values here allow a benchmark to define behaviour itself.
BenchmarkSuite.config = {
  doWarmup: undefined,
  doDeterministic: undefined
};


// Override the alert function to throw an exception instead.
var alert = function (s) {
  throw "Alert called with argument: " + s;
};


// To make the benchmark results predictable, we replace Math.random
// with a 100% deterministic alternative.
BenchmarkSuite.ResetRNG = function () {
  Math.random = (function () {
    var seed = 49734321;
    return function () {
      // Robert Jenkins' 32 bit integer hash function.
      seed = ((seed + 0x7ed55d16) + (seed << 12)) & 0xffffffff;
      seed = ((seed ^ 0xc761c23c) ^ (seed >>> 19)) & 0xffffffff;
      seed = ((seed + 0x165667b1) + (seed << 5)) & 0xffffffff;
      seed = ((seed + 0xd3a2646c) ^ (seed << 9)) & 0xffffffff;
      seed = ((seed + 0xfd7046c5) + (seed << 3)) & 0xffffffff;
      seed = ((seed ^ 0xb55a4f09) ^ (seed >>> 16)) & 0xffffffff;
      return (seed & 0xfffffff) / 0x10000000;
    };
  })();
}


// Runs all registered benchmark suites and optionally yields between
// each individual benchmark to avoid running for too long in the
// context of browsers. Once done, the final score is reported to the
// runner.
BenchmarkSuite.RunSuites = function (runner, skipBenchmarks) {
  skipBenchmarks = typeof skipBenchmarks === 'undefined' ? [] : skipBenchmarks;
  var continuation = null;
  var suites = BenchmarkSuite.suites;
  var length = suites.length;
  BenchmarkSuite.scores = [];
  var index = 0;
  function RunStep() {
    while (continuation || index < length) {
      if (continuation) {
        continuation = continuation();
      } else {
        var suite = suites[index++];
        if (runner.NotifyStart) runner.NotifyStart(suite.name);
        if (skipBenchmarks.indexOf(suite.name) > -1) {
          suite.NotifySkipped(runner);
        } else {
          continuation = suite.RunStep(runner);
        }
      }
      if (continuation && typeof window != 'undefined' && window.setTimeout) {
        window.setTimeout(RunStep, 25);
        return;
      }
    }

    // show final result
    if (runner.NotifyScore) {
      var score = BenchmarkSuite.GeometricMean(BenchmarkSuite.scores);
      var formatted = BenchmarkSuite.FormatScore(100 * score);
      runner.NotifyScore(formatted);
    }
  }
  RunStep();
}


// Counts the total number of registered benchmarks. Useful for
// showing progress as a percentage.
BenchmarkSuite.CountBenchmarks = function () {
  var result = 0;
  var suites = BenchmarkSuite.suites;
  for (var i = 0; i < suites.length; i++) {
    result += suites[i].benchmarks.length;
  }
  return result;
}


// Computes the geometric mean of a set of numbers.
BenchmarkSuite.GeometricMean = function (numbers) {
  var log = 0;
  for (var i = 0; i < numbers.length; i++) {
    log += Math.log(numbers[i]);
  }
  return Math.pow(Math.E, log / numbers.length);
}


// Computes the geometric mean of a set of throughput time measurements.
BenchmarkSuite.GeometricMeanTime = function (measurements) {
  var log = 0;
  for (var i = 0; i < measurements.length; i++) {
    log += Math.log(measurements[i].time);
  }
  return Math.pow(Math.E, log / measurements.length);
}


// Computes the geometric mean of a set of rms measurements.
BenchmarkSuite.GeometricMeanLatency = function (measurements) {
  var log = 0;
  var hasLatencyResult = false;
  for (var i = 0; i < measurements.length; i++) {
    if (measurements[i].latency != 0) {
      log += Math.log(measurements[i].latency);
      hasLatencyResult = true;
    }
  }
  if (hasLatencyResult) {
    return Math.pow(Math.E, log / measurements.length);
  } else {
    return 0;
  }
}


// Converts a score value to a string with at least three significant
// digits.
BenchmarkSuite.FormatScore = function (value) {
  if (value > 100) {
    return value.toFixed(0);
  } else {
    return value.toPrecision(3);
  }
}

// Notifies the runner that we're done running a single benchmark in
// the benchmark suite. This can be useful to report progress.
BenchmarkSuite.prototype.NotifyStep = function (result) {
  this.results.push(result);
  if (this.runner.NotifyStep) this.runner.NotifyStep(result.benchmark.name);
}


// Notifies the runner that we're done with running a suite and that
// we have a result which can be reported to the user if needed.
BenchmarkSuite.prototype.NotifyResult = function () {
  var mean = BenchmarkSuite.GeometricMeanTime(this.results);
  var score = this.reference[0] / mean;
  BenchmarkSuite.scores.push(score);
  if (this.runner.NotifyResult) {
    var formatted = BenchmarkSuite.FormatScore(100 * score);
    this.runner.NotifyResult(this.name, formatted);
  }
  if (this.reference.length == 2) {
    var meanLatency = BenchmarkSuite.GeometricMeanLatency(this.results);
    if (meanLatency != 0) {
      var scoreLatency = this.reference[1] / meanLatency;
      BenchmarkSuite.scores.push(scoreLatency);
      if (this.runner.NotifyResult) {
        var formattedLatency = BenchmarkSuite.FormatScore(100 * scoreLatency)
        this.runner.NotifyResult(this.name + "Latency", formattedLatency);
      }
    }
  }
}


BenchmarkSuite.prototype.NotifySkipped = function (runner) {
  BenchmarkSuite.scores.push(1);  // push default reference score.
  if (runner.NotifyResult) {
    runner.NotifyResult(this.name, "Skipped");
  }
}


// Notifies the runner that running a benchmark resulted in an error.
BenchmarkSuite.prototype.NotifyError = function (error) {
  if (this.runner.NotifyError) {
    this.runner.NotifyError(this.name, error);
  }
  if (this.runner.NotifyStep) {
    this.runner.NotifyStep(this.name);
  }
}


// Runs a single benchmark for at least a second and computes the
// average time it takes to run a single iteration.
BenchmarkSuite.prototype.RunSingleBenchmark = function (benchmark, data) {
  var config = BenchmarkSuite.config;
  var doWarmup = config.doWarmup !== undefined
    ? config.doWarmup
    : benchmark.doWarmup;
  var doDeterministic = config.doDeterministic !== undefined
    ? config.doDeterministic
    : benchmark.doDeterministic;

  function Measure(data) {
    var elapsed = 0;
    var start = new Date();

    // Run either for 1 second or for the number of iterations specified
    // by minIterations, depending on the config flag doDeterministic.
    for (var i = 0; (doDeterministic ?
      i < benchmark.deterministicIterations : elapsed < 1000); i++) {
      benchmark.run();
      elapsed = new Date() - start;
    }
    if (data != null) {
      data.runs += i;
      data.elapsed += elapsed;
    }
  }

  // Sets up data in order to skip or not the warmup phase.
  if (!doWarmup && data == null) {
    data = { runs: 0, elapsed: 0 };
  }

  if (data == null) {
    Measure(null);
    return { runs: 0, elapsed: 0 };
  } else {
    Measure(data);
    // If we've run too few iterations, we continue for another second.
    if (data.runs < benchmark.minIterations) return data;
    var usec = (data.elapsed * 1000) / data.runs;
    var rms = (benchmark.rmsResult != null) ? benchmark.rmsResult() : 0;
    this.NotifyStep(new BenchmarkResult(benchmark, usec, rms));
    return null;
  }
}


// This function starts running a suite, but stops between each
// individual benchmark in the suite and returns a continuation
// function which can be invoked to run the next benchmark. Once the
// last benchmark has been executed, null is returned.
BenchmarkSuite.prototype.RunStep = function (runner) {
  BenchmarkSuite.ResetRNG();
  this.results = [];
  this.runner = runner;
  var length = this.benchmarks.length;
  var index = 0;
  var suite = this;
  var data;

  // Run the setup, the actual benchmark, and the tear down in three
  // separate steps to allow the framework to yield between any of the
  // steps.

  function RunNextSetup() {
    if (index < length) {
      try {
        suite.benchmarks[index].Setup();
      } catch (e) {
        suite.NotifyError(e);
        return null;
      }
      return RunNextBenchmark;
    }
    suite.NotifyResult();
    return null;
  }

  function RunNextBenchmark() {
    try {
      data = suite.RunSingleBenchmark(suite.benchmarks[index], data);
    } catch (e) {
      suite.NotifyError(e);
      return null;
    }
    // If data is null, we're done with this benchmark.
    return (data == null) ? RunNextTearDown : RunNextBenchmark();
  }

  function RunNextTearDown() {
    try {
      suite.benchmarks[index++].TearDown();
    } catch (e) {
      suite.NotifyError(e);
      return null;
    }
    return RunNextSetup;
  }

  // Start out running the setup.
  return RunNextSetup();
}

/* raytrace.js begin */
// The ray tracer code in this file is written by Adam Burmister. It
// is available in its original form from:
//
//   http://labs.flog.nz.co/raytracer/
//
// It has been modified slightly by Google to work as a standalone
// benchmark, but the all the computational code remains
// untouched. This file also contains a copy of parts of the Prototype
// JavaScript framework which is used by the ray tracer.

var RayTrace = new BenchmarkSuite('RayTrace', [739989], [
  new Benchmark('RayTrace', true, false, 600, renderScene)
]);


// Variable used to hold a number that can be used to verify that
// the scene was ray traced correctly.
var checkNumber;


// ------------------------------------------------------------------------
// ------------------------------------------------------------------------

// The following is a copy of parts of the Prototype JavaScript library:

// Prototype JavaScript framework, version 1.5.0
// (c) 2005-2007 Sam Stephenson
//
// Prototype is freely distributable under the terms of an MIT-style license.
// For details, see the Prototype web site: http://prototype.conio.net/


var Class = {
  create: function () {
    return function () {
      this.initialize.apply(this, arguments);
    }
  }
};


Object.extend = function (destination, source) {
  for (var property in source) {
    destination[property] = source[property];
  }
  return destination;
};


// ------------------------------------------------------------------------
// ------------------------------------------------------------------------

// The rest of this file is the actual ray tracer written by Adam
// Burmister. It's a concatenation of the following files:
//
//   flog/color.js
//   flog/light.js
//   flog/vector.js
//   flog/ray.js
//   flog/scene.js
//   flog/material/basematerial.js
//   flog/material/solid.js
//   flog/material/chessboard.js
//   flog/shape/baseshape.js
//   flog/shape/sphere.js
//   flog/shape/plane.js
//   flog/intersectioninfo.js
//   flog/camera.js
//   flog/background.js
//   flog/engine.js


/* Fake a Flog.* namespace */
if (typeof (Flog) == 'undefined') var Flog = {};
if (typeof (Flog.RayTracer) == 'undefined') Flog.RayTracer = {};

Flog.RayTracer.Color = Class.create();

Flog.RayTracer.Color.prototype = {
  red: 0.0,
  green: 0.0,
  blue: 0.0,

  initialize: function (r, g, b) {
    if (!r) r = 0.0;
    if (!g) g = 0.0;
    if (!b) b = 0.0;

    this.red = r;
    this.green = g;
    this.blue = b;
  },

  add: function (c1, c2) {
    var result = new Flog.RayTracer.Color(0, 0, 0);

    result.red = c1.red + c2.red;
    result.green = c1.green + c2.green;
    result.blue = c1.blue + c2.blue;

    return result;
  },

  addScalar: function (c1, s) {
    var result = new Flog.RayTracer.Color(0, 0, 0);

    result.red = c1.red + s;
    result.green = c1.green + s;
    result.blue = c1.blue + s;

    result.limit();

    return result;
  },

  subtract: function (c1, c2) {
    var result = new Flog.RayTracer.Color(0, 0, 0);

    result.red = c1.red - c2.red;
    result.green = c1.green - c2.green;
    result.blue = c1.blue - c2.blue;

    return result;
  },

  multiply: function (c1, c2) {
    var result = new Flog.RayTracer.Color(0, 0, 0);

    result.red = c1.red * c2.red;
    result.green = c1.green * c2.green;
    result.blue = c1.blue * c2.blue;

    return result;
  },

  multiplyScalar: function (c1, f) {
    var result = new Flog.RayTracer.Color(0, 0, 0);

    result.red = c1.red * f;
    result.green = c1.green * f;
    result.blue = c1.blue * f;

    return result;
  },

  divideFactor: function (c1, f) {
    var result = new Flog.RayTracer.Color(0, 0, 0);

    result.red = c1.red / f;
    result.green = c1.green / f;
    result.blue = c1.blue / f;

    return result;
  },

  limit: function () {
    this.red = (this.red > 0.0) ? ((this.red > 1.0) ? 1.0 : this.red) : 0.0;
    this.green = (this.green > 0.0) ? ((this.green > 1.0) ? 1.0 : this.green) : 0.0;
    this.blue = (this.blue > 0.0) ? ((this.blue > 1.0) ? 1.0 : this.blue) : 0.0;
  },

  distance: function (color) {
    var d = Math.abs(this.red - color.red) + Math.abs(this.green - color.green) + Math.abs(this.blue - color.blue);
    return d;
  },

  blend: function (c1, c2, w) {
    var result = new Flog.RayTracer.Color(0, 0, 0);
    result = Flog.RayTracer.Color.prototype.add(
      Flog.RayTracer.Color.prototype.multiplyScalar(c1, 1 - w),
      Flog.RayTracer.Color.prototype.multiplyScalar(c2, w)
    );
    return result;
  },

  brightness: function () {
    var r = Math.floor(this.red * 255);
    var g = Math.floor(this.green * 255);
    var b = Math.floor(this.blue * 255);
    return (r * 77 + g * 150 + b * 29) >> 8;
  },

  toString: function () {
    var r = Math.floor(this.red * 255);
    var g = Math.floor(this.green * 255);
    var b = Math.floor(this.blue * 255);

    return "rgb(" + r + "," + g + "," + b + ")";
  }
}
/* Fake a Flog.* namespace */
if (typeof (Flog) == 'undefined') var Flog = {};
if (typeof (Flog.RayTracer) == 'undefined') Flog.RayTracer = {};

Flog.RayTracer.Light = Class.create();

Flog.RayTracer.Light.prototype = {
  position: null,
  color: null,
  intensity: 10.0,

  initialize: function (pos, color, intensity) {
    this.position = pos;
    this.color = color;
    this.intensity = (intensity ? intensity : 10.0);
  },

  toString: function () {
    return 'Light [' + this.position.x + ',' + this.position.y + ',' + this.position.z + ']';
  }
}
/* Fake a Flog.* namespace */
if (typeof (Flog) == 'undefined') var Flog = {};
if (typeof (Flog.RayTracer) == 'undefined') Flog.RayTracer = {};

Flog.RayTracer.Vector = Class.create();

Flog.RayTracer.Vector.prototype = {
  x: 0.0,
  y: 0.0,
  z: 0.0,

  initialize: function (x, y, z) {
    this.x = (x ? x : 0);
    this.y = (y ? y : 0);
    this.z = (z ? z : 0);
  },

  copy: function (vector) {
    this.x = vector.x;
    this.y = vector.y;
    this.z = vector.z;
  },

  normalize: function () {
    var m = this.magnitude();
    return new Flog.RayTracer.Vector(this.x / m, this.y / m, this.z / m);
  },

  magnitude: function () {
    return Math.sqrt((this.x * this.x) + (this.y * this.y) + (this.z * this.z));
  },

  cross: function (w) {
    return new Flog.RayTracer.Vector(
      -this.z * w.y + this.y * w.z,
      this.z * w.x - this.x * w.z,
      -this.y * w.x + this.x * w.y);
  },

  dot: function (w) {
    return this.x * w.x + this.y * w.y + this.z * w.z;
  },

  add: function (v, w) {
    return new Flog.RayTracer.Vector(w.x + v.x, w.y + v.y, w.z + v.z);
  },

  subtract: function (v, w) {
    if (!w || !v) throw 'Vectors must be defined [' + v + ',' + w + ']';
    return new Flog.RayTracer.Vector(v.x - w.x, v.y - w.y, v.z - w.z);
  },

  multiplyVector: function (v, w) {
    return new Flog.RayTracer.Vector(v.x * w.x, v.y * w.y, v.z * w.z);
  },

  multiplyScalar: function (v, w) {
    return new Flog.RayTracer.Vector(v.x * w, v.y * w, v.z * w);
  },

  toString: function () {
    return 'Vector [' + this.x + ',' + this.y + ',' + this.z + ']';
  }
}
/* Fake a Flog.* namespace */
if (typeof (Flog) == 'undefined') var Flog = {};
if (typeof (Flog.RayTracer) == 'undefined') Flog.RayTracer = {};

Flog.RayTracer.Ray = Class.create();

Flog.RayTracer.Ray.prototype = {
  position: null,
  direction: null,
  initialize: function (pos, dir) {
    this.position = pos;
    this.direction = dir;
  },

  toString: function () {
    return 'Ray [' + this.position + ',' + this.direction + ']';
  }
}
/* Fake a Flog.* namespace */
if (typeof (Flog) == 'undefined') var Flog = {};
if (typeof (Flog.RayTracer) == 'undefined') Flog.RayTracer = {};

Flog.RayTracer.Scene = Class.create();

Flog.RayTracer.Scene.prototype = {
  camera: null,
  shapes: [],
  lights: [],
  background: null,

  initialize: function () {
    this.camera = new Flog.RayTracer.Camera(
      new Flog.RayTracer.Vector(0, 0, -5),
      new Flog.RayTracer.Vector(0, 0, 1),
      new Flog.RayTracer.Vector(0, 1, 0)
    );
    this.shapes = new Array();
    this.lights = new Array();
    this.background = new Flog.RayTracer.Background(new Flog.RayTracer.Color(0, 0, 0.5), 0.2);
  }
}
/* Fake a Flog.* namespace */
if (typeof (Flog) == 'undefined') var Flog = {};
if (typeof (Flog.RayTracer) == 'undefined') Flog.RayTracer = {};
if (typeof (Flog.RayTracer.Material) == 'undefined') Flog.RayTracer.Material = {};

Flog.RayTracer.Material.BaseMaterial = Class.create();

Flog.RayTracer.Material.BaseMaterial.prototype = {

  gloss: 2.0,             // [0...infinity] 0 = matt
  transparency: 0.0,      // 0=opaque
  reflection: 0.0,        // [0...infinity] 0 = no reflection
  refraction: 0.50,
  hasTexture: false,

  initialize: function () {

  },

  getColor: function (u, v) {

  },

  wrapUp: function (t) {
    t = t % 2.0;
    if (t < -1) t += 2.0;
    if (t >= 1) t -= 2.0;
    return t;
  },

  toString: function () {
    return 'Material [gloss=' + this.gloss + ', transparency=' + this.transparency + ', hasTexture=' + this.hasTexture + ']';
  }
}
/* Fake a Flog.* namespace */
if (typeof (Flog) == 'undefined') var Flog = {};
if (typeof (Flog.RayTracer) == 'undefined') Flog.RayTracer = {};

Flog.RayTracer.Material.Solid = Class.create();

Flog.RayTracer.Material.Solid.prototype = Object.extend(
  new Flog.RayTracer.Material.BaseMaterial(), {
  initialize: function (color, reflection, refraction, transparency, gloss) {
    this.color = color;
    this.reflection = reflection;
    this.transparency = transparency;
    this.gloss = gloss;
    this.hasTexture = false;
  },

  getColor: function (u, v) {
    return this.color;
  },

  toString: function () {
    return 'SolidMaterial [gloss=' + this.gloss + ', transparency=' + this.transparency + ', hasTexture=' + this.hasTexture + ']';
  }
}
);
/* Fake a Flog.* namespace */
if (typeof (Flog) == 'undefined') var Flog = {};
if (typeof (Flog.RayTracer) == 'undefined') Flog.RayTracer = {};

Flog.RayTracer.Material.Chessboard = Class.create();

Flog.RayTracer.Material.Chessboard.prototype = Object.extend(
  new Flog.RayTracer.Material.BaseMaterial(), {
  colorEven: null,
  colorOdd: null,
  density: 0.5,

  initialize: function (colorEven, colorOdd, reflection, transparency, gloss, density) {
    this.colorEven = colorEven;
    this.colorOdd = colorOdd;
    this.reflection = reflection;
    this.transparency = transparency;
    this.gloss = gloss;
    this.density = density;
    this.hasTexture = true;
  },

  getColor: function (u, v) {
    var t = this.wrapUp(u * this.density) * this.wrapUp(v * this.density);

    if (t < 0.0)
      return this.colorEven;
    else
      return this.colorOdd;
  },

  toString: function () {
    return 'ChessMaterial [gloss=' + this.gloss + ', transparency=' + this.transparency + ', hasTexture=' + this.hasTexture + ']';
  }
}
);
/* Fake a Flog.* namespace */
if (typeof (Flog) == 'undefined') var Flog = {};
if (typeof (Flog.RayTracer) == 'undefined') Flog.RayTracer = {};
if (typeof (Flog.RayTracer.Shape) == 'undefined') Flog.RayTracer.Shape = {};

Flog.RayTracer.Shape.Sphere = Class.create();

Flog.RayTracer.Shape.Sphere.prototype = {
  initialize: function (pos, radius, material) {
    this.radius = radius;
    this.position = pos;
    this.material = material;
  },

  intersect: function (ray) {
    var info = new Flog.RayTracer.IntersectionInfo();
    info.shape = this;

    var dst = Flog.RayTracer.Vector.prototype.subtract(ray.position, this.position);

    var B = dst.dot(ray.direction);
    var C = dst.dot(dst) - (this.radius * this.radius);
    var D = (B * B) - C;

    if (D > 0) { // intersection!
      info.isHit = true;
      info.distance = (-B) - Math.sqrt(D);
      info.position = Flog.RayTracer.Vector.prototype.add(
        ray.position,
        Flog.RayTracer.Vector.prototype.multiplyScalar(
          ray.direction,
          info.distance
        )
      );
      info.normal = Flog.RayTracer.Vector.prototype.subtract(
        info.position,
        this.position
      ).normalize();

      info.color = this.material.getColor(0, 0);
    } else {
      info.isHit = false;
    }
    return info;
  },

  toString: function () {
    return 'Sphere [position=' + this.position + ', radius=' + this.radius + ']';
  }
}
/* Fake a Flog.* namespace */
if (typeof (Flog) == 'undefined') var Flog = {};
if (typeof (Flog.RayTracer) == 'undefined') Flog.RayTracer = {};
if (typeof (Flog.RayTracer.Shape) == 'undefined') Flog.RayTracer.Shape = {};

Flog.RayTracer.Shape.Plane = Class.create();

Flog.RayTracer.Shape.Plane.prototype = {
  d: 0.0,

  initialize: function (pos, d, material) {
    this.position = pos;
    this.d = d;
    this.material = material;
  },

  intersect: function (ray) {
    var info = new Flog.RayTracer.IntersectionInfo();

    var Vd = this.position.dot(ray.direction);
    if (Vd == 0) return info; // no intersection

    var t = -(this.position.dot(ray.position) + this.d) / Vd;
    if (t <= 0) return info;

    info.shape = this;
    info.isHit = true;
    info.position = Flog.RayTracer.Vector.prototype.add(
      ray.position,
      Flog.RayTracer.Vector.prototype.multiplyScalar(
        ray.direction,
        t
      )
    );
    info.normal = this.position;
    info.distance = t;

    if (this.material.hasTexture) {
      var vU = new Flog.RayTracer.Vector(this.position.y, this.position.z, -this.position.x);
      var vV = vU.cross(this.position);
      var u = info.position.dot(vU);
      var v = info.position.dot(vV);
      info.color = this.material.getColor(u, v);
    } else {
      info.color = this.material.getColor(0, 0);
    }

    return info;
  },

  toString: function () {
    return 'Plane [' + this.position + ', d=' + this.d + ']';
  }
}
/* Fake a Flog.* namespace */
if (typeof (Flog) == 'undefined') var Flog = {};
if (typeof (Flog.RayTracer) == 'undefined') Flog.RayTracer = {};

Flog.RayTracer.IntersectionInfo = Class.create();

Flog.RayTracer.IntersectionInfo.prototype = {
  isHit: false,
  hitCount: 0,
  shape: null,
  position: null,
  normal: null,
  color: null,
  distance: null,

  initialize: function () {
    this.color = new Flog.RayTracer.Color(0, 0, 0);
  },

  toString: function () {
    return 'Intersection [' + this.position + ']';
  }
}
/* Fake a Flog.* namespace */
if (typeof (Flog) == 'undefined') var Flog = {};
if (typeof (Flog.RayTracer) == 'undefined') Flog.RayTracer = {};

Flog.RayTracer.Camera = Class.create();

Flog.RayTracer.Camera.prototype = {
  position: null,
  lookAt: null,
  equator: null,
  up: null,
  screen: null,

  initialize: function (pos, lookAt, up) {
    this.position = pos;
    this.lookAt = lookAt;
    this.up = up;
    this.equator = lookAt.normalize().cross(this.up);
    this.screen = Flog.RayTracer.Vector.prototype.add(this.position, this.lookAt);
  },

  getRay: function (vx, vy) {
    var pos = Flog.RayTracer.Vector.prototype.subtract(
      this.screen,
      Flog.RayTracer.Vector.prototype.subtract(
        Flog.RayTracer.Vector.prototype.multiplyScalar(this.equator, vx),
        Flog.RayTracer.Vector.prototype.multiplyScalar(this.up, vy)
      )
    );
    pos.y = pos.y * -1;
    var dir = Flog.RayTracer.Vector.prototype.subtract(
      pos,
      this.position
    );

    var ray = new Flog.RayTracer.Ray(pos, dir.normalize());

    return ray;
  },

  toString: function () {
    return 'Ray []';
  }
}
/* Fake a Flog.* namespace */
if (typeof (Flog) == 'undefined') var Flog = {};
if (typeof (Flog.RayTracer) == 'undefined') Flog.RayTracer = {};

Flog.RayTracer.Background = Class.create();

Flog.RayTracer.Background.prototype = {
  color: null,
  ambience: 0.0,

  initialize: function (color, ambience) {
    this.color = color;
    this.ambience = ambience;
  }
}
/* Fake a Flog.* namespace */
if (typeof (Flog) == 'undefined') var Flog = {};
if (typeof (Flog.RayTracer) == 'undefined') Flog.RayTracer = {};

Flog.RayTracer.Engine = Class.create();

Flog.RayTracer.Engine.prototype = {
  canvas: null, /* 2d context we can render to */

  initialize: function (options) {
    this.options = Object.extend({
      canvasHeight: 100,
      canvasWidth: 100,
      pixelWidth: 2,
      pixelHeight: 2,
      renderDiffuse: false,
      renderShadows: false,
      renderHighlights: false,
      renderReflections: false,
      rayDepth: 2
    }, options || {});

    this.options.canvasHeight /= this.options.pixelHeight;
    this.options.canvasWidth /= this.options.pixelWidth;

    /* TODO: dynamically include other scripts */
  },

  setPixel: function (x, y, color) {
    var pxW, pxH;
    pxW = this.options.pixelWidth;
    pxH = this.options.pixelHeight;

    if (this.canvas) {
      this.canvas.fillStyle = color.toString();
      this.canvas.fillRect(x * pxW, y * pxH, pxW, pxH);
    } else {
      if (x === y) {
        checkNumber += color.brightness();
      }
      // print(x * pxW, y * pxH, pxW, pxH);
    }
  },

  renderScene: function (scene, canvas) {
    checkNumber = 0;
    /* Get canvas */
    if (canvas) {
      this.canvas = canvas.getContext("2d");
    } else {
      this.canvas = null;
    }

    var canvasHeight = this.options.canvasHeight;
    var canvasWidth = this.options.canvasWidth;

    for (var y = 0; y < canvasHeight; y++) {
      for (var x = 0; x < canvasWidth; x++) {
        var yp = y * 1.0 / canvasHeight * 2 - 1;
        var xp = x * 1.0 / canvasWidth * 2 - 1;

        var ray = scene.camera.getRay(xp, yp);

        var color = this.getPixelColor(ray, scene);

        this.setPixel(x, y, color);
      }
    }
    if (checkNumber !== 2321) {
      throw new Error("Scene rendered incorrectly");
    }
  },

  getPixelColor: function (ray, scene) {
    var info = this.testIntersection(ray, scene, null);
    if (info.isHit) {
      var color = this.rayTrace(info, ray, scene, 0);
      return color;
    }
    return scene.background.color;
  },

  testIntersection: function (ray, scene, exclude) {
    var hits = 0;
    var best = new Flog.RayTracer.IntersectionInfo();
    best.distance = 2000;

    for (var i = 0; i < scene.shapes.length; i++) {
      var shape = scene.shapes[i];

      if (shape != exclude) {
        var info = shape.intersect(ray);
        if (info.isHit && info.distance >= 0 && info.distance < best.distance) {
          best = info;
          hits++;
        }
      }
    }
    best.hitCount = hits;
    return best;
  },

  getReflectionRay: function (P, N, V) {
    var c1 = -N.dot(V);
    var R1 = Flog.RayTracer.Vector.prototype.add(
      Flog.RayTracer.Vector.prototype.multiplyScalar(N, 2 * c1),
      V
    );
    return new Flog.RayTracer.Ray(P, R1);
  },

  rayTrace: function (info, ray, scene, depth) {
    // Calc ambient
    var color = Flog.RayTracer.Color.prototype.multiplyScalar(info.color, scene.background.ambience);
    var oldColor = color;
    var shininess = Math.pow(10, info.shape.material.gloss + 1);

    for (var i = 0; i < scene.lights.length; i++) {
      var light = scene.lights[i];

      // Calc diffuse lighting
      var v = Flog.RayTracer.Vector.prototype.subtract(
        light.position,
        info.position
      ).normalize();

      if (this.options.renderDiffuse) {
        var L = v.dot(info.normal);
        if (L > 0.0) {
          color = Flog.RayTracer.Color.prototype.add(
            color,
            Flog.RayTracer.Color.prototype.multiply(
              info.color,
              Flog.RayTracer.Color.prototype.multiplyScalar(
                light.color,
                L
              )
            )
          );
        }
      }

      // The greater the depth the more accurate the colours, but
      // this is exponentially (!) expensive
      if (depth <= this.options.rayDepth) {
        // calculate reflection ray
        if (this.options.renderReflections && info.shape.material.reflection > 0) {
          var reflectionRay = this.getReflectionRay(info.position, info.normal, ray.direction);
          var refl = this.testIntersection(reflectionRay, scene, info.shape);

          if (refl.isHit && refl.distance > 0) {
            refl.color = this.rayTrace(refl, reflectionRay, scene, depth + 1);
          } else {
            refl.color = scene.background.color;
          }

          color = Flog.RayTracer.Color.prototype.blend(
            color,
            refl.color,
            info.shape.material.reflection
          );
        }

        // Refraction
        /* TODO */
      }

      /* Render shadows and highlights */

      var shadowInfo = new Flog.RayTracer.IntersectionInfo();

      if (this.options.renderShadows) {
        var shadowRay = new Flog.RayTracer.Ray(info.position, v);

        shadowInfo = this.testIntersection(shadowRay, scene, info.shape);
        if (shadowInfo.isHit && shadowInfo.shape != info.shape /*&& shadowInfo.shape.type != 'PLANE'*/) {
          var vA = Flog.RayTracer.Color.prototype.multiplyScalar(color, 0.5);
          var dB = (0.5 * Math.pow(shadowInfo.shape.material.transparency, 0.5));
          color = Flog.RayTracer.Color.prototype.addScalar(vA, dB);
        }
      }

      // Phong specular highlights
      if (this.options.renderHighlights && !shadowInfo.isHit && info.shape.material.gloss > 0) {
        var Lv = Flog.RayTracer.Vector.prototype.subtract(
          info.shape.position,
          light.position
        ).normalize();

        var E = Flog.RayTracer.Vector.prototype.subtract(
          scene.camera.position,
          info.shape.position
        ).normalize();

        var H = Flog.RayTracer.Vector.prototype.subtract(
          E,
          Lv
        ).normalize();

        var glossWeight = Math.pow(Math.max(info.normal.dot(H), 0), shininess);
        color = Flog.RayTracer.Color.prototype.add(
          Flog.RayTracer.Color.prototype.multiplyScalar(light.color, glossWeight),
          color
        );
      }
    }
    color.limit();
    return color;
  }
};


function renderScene() {
  var scene = new Flog.RayTracer.Scene();

  scene.camera = new Flog.RayTracer.Camera(
    new Flog.RayTracer.Vector(0, 0, -15),
    new Flog.RayTracer.Vector(-0.2, 0, 5),
    new Flog.RayTracer.Vector(0, 1, 0)
  );

  scene.background = new Flog.RayTracer.Background(
    new Flog.RayTracer.Color(0.5, 0.5, 0.5),
    0.4
  );

  var sphere = new Flog.RayTracer.Shape.Sphere(
    new Flog.RayTracer.Vector(-1.5, 1.5, 2),
    1.5,
    new Flog.RayTracer.Material.Solid(
      new Flog.RayTracer.Color(0, 0.5, 0.5),
      0.3,
      0.0,
      0.0,
      2.0
    )
  );

  var sphere1 = new Flog.RayTracer.Shape.Sphere(
    new Flog.RayTracer.Vector(1, 0.25, 1),
    0.5,
    new Flog.RayTracer.Material.Solid(
      new Flog.RayTracer.Color(0.9, 0.9, 0.9),
      0.1,
      0.0,
      0.0,
      1.5
    )
  );

  var plane = new Flog.RayTracer.Shape.Plane(
    new Flog.RayTracer.Vector(0.1, 0.9, -0.5).normalize(),
    1.2,
    new Flog.RayTracer.Material.Chessboard(
      new Flog.RayTracer.Color(1, 1, 1),
      new Flog.RayTracer.Color(0, 0, 0),
      0.2,
      0.0,
      1.0,
      0.7
    )
  );

  scene.shapes.push(plane);
  scene.shapes.push(sphere);
  scene.shapes.push(sphere1);

  var light = new Flog.RayTracer.Light(
    new Flog.RayTracer.Vector(5, 10, -1),
    new Flog.RayTracer.Color(0.8, 0.8, 0.8)
  );

  var light1 = new Flog.RayTracer.Light(
    new Flog.RayTracer.Vector(-3, 5, -15),
    new Flog.RayTracer.Color(0.8, 0.8, 0.8),
    100
  );

  scene.lights.push(light);
  scene.lights.push(light1);

  var imageWidth = 100; // $F('imageWidth');
  var imageHeight = 100; // $F('imageHeight');
  var pixelSize = "5,5".split(','); //  $F('pixelSize').split(',');
  var renderDiffuse = true; // $F('renderDiffuse');
  var renderShadows = true; // $F('renderShadows');
  var renderHighlights = true; // $F('renderHighlights');
  var renderReflections = true; // $F('renderReflections');
  var rayDepth = 2;//$F('rayDepth');

  var raytracer = new Flog.RayTracer.Engine(
    {
      canvasWidth: imageWidth,
      canvasHeight: imageHeight,
      pixelWidth: pixelSize[0],
      pixelHeight: pixelSize[1],
      "renderDiffuse": renderDiffuse,
      "renderHighlights": renderHighlights,
      "renderShadows": renderShadows,
      "renderReflections": renderReflections,
      "rayDepth": rayDepth
    }
  );

  raytracer.renderScene(scene, null, 0);
}
/* raytrace.js end */

/*
  Copyright (C) 2014, Daishi Kato <daishi@axlight.com>
  Copyright (C) 2014, Etienne Rossignon
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are

    * Redistributions of source code must retain the above copyright
      notice, this list of conditions and the following disclaimer.
    * Redistributions in binary form must reproduce the above copyright
      notice, this list of conditions and the following disclaimer in th
      documentation and/or other materials provided with the distributio

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

/* global BenchmarkSuite: false */

// var vm = require('vm');
// var fs = require('fs');
// var path = require('path');
// var os = require('os');

// GLOBAL.print = function(str) {
//   console.log(str);
// };

// GLOBAL.read = function(a, b) {
//   var a = path.normalize(a);
//   var c = fs.readFileSync(a);
//   if (!c && a != path.resolve(a)) {
//     a = path.join(__dirname, '..', 'src', a);
//     c = fs.readFileSync(a);
//   }
//   if (c && !b) {
//     c = c.toString();
//   }
//   return c;
// };

// function load(filename) {
//   vm.runInThisContext(fs.readFileSync(filename, 'utf8'), filename);
// }

// var base_dir = __dirname + '/octane/';

// load(base_dir + 'base.js');
// load(base_dir + 'richards.js');
// load(base_dir + 'deltablue.js');
// load(base_dir + 'crypto.js');
// load(base_dir + 'raytrace.js');
// load(base_dir + 'earley-boyer.js');
// load(base_dir + 'regexp.js');
// load(base_dir + 'splay.js');
// load(base_dir + 'navier-stokes.js');
// load(base_dir + 'pdfjs.js');
// load(base_dir + 'mandreel.js');
// load(base_dir + 'gbemu-part1.js');
// load(base_dir + 'gbemu-part2.js');
// load(base_dir + 'code-load.js');
// load(base_dir + 'box2d.js');
// load(base_dir + 'zlib.js');
// load(base_dir + 'zlib-data.js');
// load(base_dir + 'typescript.js');
// load(base_dir + 'typescript-input.js');
// load(base_dir + 'typescript-compiler.js');


var success = true;

function PrintResult(name, result) {
  print((name + '                      ').substr(0, 20) + ': ' + result);
}

function PrintError(name, error) {
  PrintResult(name, error);
  success = false;
}

function PrintScore(score) {
  // if (success) {
  //   print('----');
  //   print('Score (version ' + BenchmarkSuite.version + '): ' + score);
  // }
}

BenchmarkSuite.config.doWarmup = undefined;
BenchmarkSuite.config.doDeterministic = undefined;

BenchmarkSuite.RunSuites({
  NotifyResult: PrintResult,
  NotifyError: PrintError,
  NotifyScore: PrintScore
});
